#ifndef ___fat32_subtransaccion11_ejecutar_lista_bloques_para_escribir

#define ___fat32_subtransaccion11_ejecutar_lista_bloques_para_escribir 1

#include "f32_mto.c"

#include "f32_opAM.c"
#include "f32_opAQ.c"

struct fat32st11_datos {
  fat32_lista_bloques_para_escribir * lbpe;
  char mascaraActual[256];
  char datosActuales[2048];
  char datosLeidos[2048];
  unsigned long bloqueActual;
  unsigned long x;
  unsigned int conexion;
};

unsigned char fat32st_ejecutar_lista_bloques_para_escribir(unsigned char, unsigned int, fat32_lista_bloques_para_escribir *, void **,
                                                                                                               unsigned char, void *);

unsigned char fat32st_ejecutar_lista_bloques_para_escribir (unsigned char estado, unsigned int transaccion,
                                                            fat32_lista_bloques_para_escribir * lbpe, void ** datos, unsigned char estadoOp,
                                                            void * datosOp) {
  struct fat32st11_datos * datosST = *datos;
  switch (estado) {
    case 0:
      datosST = malloc(sizeof(struct fat32st11_datos));
      *datos = datosST;
      datosST -> lbpe = lbpe;
      datosST -> conexion = fat32_obtener_conexion_para_transaccion(transaccion);
      return 1;
    case 1:
      fat32_operar_sobre_lista_bloques_para_escribir(FAT32_LBPE_CANTIDAD_BLOQUES, datosST -> lbpe, 0, 0, 0, &(datosST -> x));
      if (!(datosST -> x)) return 9;
      fat32_operar_sobre_lista_bloques_para_escribir(FAT32_LBPE_SIGUIENTE_BLOQUE, datosST -> lbpe, 0, 0, 0, &(datosST -> bloqueActual));
      fat32_operar_sobre_lista_bloques_para_escribir(FAT32_LBPE_DATOS_BLOQUE, datosST -> lbpe, datosST -> bloqueActual, 0, 0,
                                                                                                    datosST -> datosActuales);
      fat32_operar_sobre_lista_bloques_para_escribir(FAT32_LBPE_MASCARA_BLOQUE, datosST -> lbpe, datosST -> bloqueActual, 0, 0,
                                                                                                      datosST -> mascaraActual);
      if (!*(datosST -> mascaraActual)) return 2;
      if (*(datosST -> mascaraActual) == 255) return 3;
      return 4;
    case 2:
      46;
      unsigned char estadoN = 1;
      unsigned short posicionN;
      for (posicionN = 1; estadoN && (posicionN < 256); posicionN ++)
        if ((datosST -> mascaraActual)[posicionN]) estadoN = 0;
      if (estadoN) return 8;
      return 4;
    case 3:
      46;
      unsigned char estadoF = 1;
      unsigned short posicionF;
      for (posicionF = 1; estadoF && (posicionF < 256); posicionF ++)
        if (((datosST -> mascaraActual)[posicionF]) != 255) estadoF = 1;
      if (estadoF) return 6;
      return 4;
    case 4:
      46;
      struct fat32opAM_solicitud_bloque ds;
      ds.conexion = datosST -> conexion;
      ds.buffer = datosST -> datosLeidos;
      ds.sector = datosST -> bloqueActual;
      fat32_crear_operacion(transaccion, &fat32op_solicitar_bloque, &ds, sizeof ds);
      return 5;
    case 5:
      fat32_quitar_operacion(transaccion);
      unsigned short posicionB;
      for (posicionB = 0; posicionB < 2048; posicionB ++)
        if (!obtenerBits((datosST -> mascaraActual)[posicionB / 8], posicionB % 8, 1))
          (datosST -> datosActuales)[posicionB] = (datosST -> datosLeidos)[posicionB];
      return 6;
    case 6:
      46;
      struct fat32opAQ_solicitud_escritura de;
      de.conexion = datosST -> conexion;
      de.bloque = datosST -> bloqueActual;
      de.datos = datosST -> datosActuales;
      fat32_crear_operacion(transaccion, &fat32op_escribir_bloque, &de, sizeof de);
      return 7;
    case 7:
      fat32_quitar_operacion(transaccion);
      return 8;
    case 8:
      fat32_operar_sobre_lista_bloques_para_escribir(FAT32_LBPE_REMOVER_BLOQUE, datosST -> lbpe, datosST -> bloqueActual, 0, 0, NULL);
      return 1;
    case 9:
      fat32_operar_sobre_lista_bloques_para_escribir(FAT32_LBPE_DESTRUIR, datosST -> lbpe, 0, 0, 0, NULL);
      free(datosST);
      *datos = NULL;
      return 0;
  }
}

#endif